import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from '../../entities/user.entity';
import { Article } from '../../entities/article.entity';
import { Comment } from '../../entities/comment.entity';
import { Like } from '../../entities/like.entity';
import * as si from 'systeminformation';


@Injectable()
export class CommonService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
    @InjectRepository(Article)
    private articleRepository: Repository<Article>,
    @InjectRepository(Comment)
    private commentRepository: Repository<Comment>,
    @InjectRepository(Like)
    private likeRepository: Repository<Like>,
  ) {}

  /**
   * 获取系统统计信息
   * 包括用户总数、文章总数、评论总数、点赞总数等
   */
  async getSystemStats(): Promise<any> {
    // 并发执行所有统计查询，提高性能
    const [
      totalUsers,
      totalArticles,
      totalApprovedArticles,
      totalComments,
      totalLikes,
      totalAdmins,
      totalNormalUsers,
    ] = await Promise.all([
      // 获取用户总数
      this.userRepository.count(),
      // 获取文章总数（包括所有状态）
      this.articleRepository.count(),
      // 获取已审核通过的文章数
      this.articleRepository.count({ where: { isActive: Article.STATUS_APPROVED } }),
      // 获取评论总数
      this.commentRepository.count(),
      // 获取点赞总数
      this.likeRepository.count(),
      // 获取管理员用户数
      this.userRepository.count({ where: { role: 1 } }),
      // 获取普通用户数
      this.userRepository.count({ where: { role: 0 } }),
    ]);

    return {
      // 用户相关统计
      userStats: {
        total: totalUsers,
        adminCount: totalAdmins,
        normalUserCount: totalNormalUsers,
      },
      // 文章相关统计
      articleStats: {
        total: totalArticles,
        approvedCount: totalApprovedArticles,
        pendingCount: totalArticles - totalApprovedArticles,
      },
      // 评论总数
      commentCount: totalComments,
      // 点赞总数
      likeCount: totalLikes,
      // 系统时间（用于前端显示）
      systemTime: new Date(),
    };
  }

  /**
   * 获取系统状态信息
   * 包括CPU使用率、内存使用率、服务器程序内存占用和服务器程序运行时间
   */
  async getSystemStatus() {
    try {
      // 使用systeminformation库获取CPU使用率
      const cpuData = await si.currentLoad();
      const cpuUsage = cpuData.currentLoad; // CPU整体使用率（%）
      
      // 使用systeminformation库获取内存信息
      const memoryData = await si.mem();
      const memoryUsage = ((memoryData.total - memoryData.available) / memoryData.total) * 100;
      
      // 获取当前进程的内存占用（MB）
      const processMemMB = process.memoryUsage().heapUsed / 1024 / 1024;
      
      // 计算服务器程序运行时间
      const uptimeSeconds = process.uptime();
      const days = Math.floor(uptimeSeconds / 86400);
      const hours = Math.floor((uptimeSeconds % 86400) / 3600);
      const minutes = Math.floor((uptimeSeconds % 3600) / 60);
      const seconds = Math.floor(uptimeSeconds % 60);
      
      let uptimeStr = '';
      if (days > 0) uptimeStr += `${days}天 `;
      if (hours > 0 || days > 0) uptimeStr += `${hours}小时 `;
      if (minutes > 0 || hours > 0 || days > 0) uptimeStr += `${minutes}分钟 `;
      uptimeStr += `${seconds}秒`;
      
      return {
        cpuUsage: parseFloat(cpuUsage.toFixed(2)),           // CPU使用率（%）
        memoryUsage: parseFloat(memoryUsage.toFixed(2)),     // 系统内存使用率（%）
        processMemMB: parseFloat(processMemMB.toFixed(2)),   // 服务器程序内存占用（MB）
        uptime: uptimeStr                                    // 服务器程序运行时间
      };
    } catch (error) {
      // console.error('获取系统状态失败:', error);
      // 错误情况下返回默认值
      return {
        cpuUsage: 0,
        memoryUsage: 0,
        processMemMB: 0,
        uptime: '未知'
      };
    }
  }



  /**
   * 获取热门文章排行
   * 根据浏览量排序，返回前10篇文章的标题、作者、浏览量和点赞数
   */
  async getHotArticles() {
    try {
      // 查询文章，按浏览量降序排列，获取前10篇
      const hotArticles = await this.articleRepository
        .createQueryBuilder('article')
        // 只选择需要的字段
        .select(['article.id', 'article.title', 'article.viewCount', 'article.authorId' ,'article.likeCount'])
        // 按浏览量降序排序
        .orderBy('article.viewCount', 'DESC')
        // 限制返回10条记录
        .limit(10)
        .getMany();

      // 获取每篇文章的作者信息和点赞数
      const articlesWithDetails = await Promise.all(
        hotArticles.map(async (article) => {
          // 单独查询作者信息
          const author = await this.userRepository.findOne({
            where: { id: article.authorId },
            select: ['username']
          });

          // 查询当前文章的点赞数量
          // const likeCount = await this.likeRepository.count({
          //   where: { articleId: article.id },
          // });

          return {
            title: article.title,
            author: author?.username || '未知作者',
            viewCount: article.viewCount,
            likeCount: article.likeCount,
          };
        })
      );

      return articlesWithDetails;
    } catch (error) {
      // 错误处理
      console.error('获取热门文章失败:', error);
      return [];
    }
  }
}
